package edu.fourtwelve.util;

import java.util.logging.Logger;
import javax.xml.bind.DatatypeConverter;

/**
 *
 * @author Christopher C. Hunt
 */
public class Utils {

    private static final Logger log = Logger.getLogger(Utils.class.getName());

    public static byte[] intToByteArray(int i) {
        return new byte[]{
                    (byte) (i >>> 24),
                    (byte) (i >>> 16),
                    (byte) (i >>> 8),
                    (byte) (i)
                };
    }

    public static byte[] longToByteArray(long i) {
        return new byte[]{
                    (byte) (i >>> 56),
                    (byte) (i >>> 48),
                    (byte) (i >>> 40),
                    (byte) (i >>> 32),
                    (byte) (i >>> 24),
                    (byte) (i >>> 16),
                    (byte) (i >>> 8),
                    (byte) (i)
                };
    }

    public static int byteArrayToInt(byte[] b) {
        if (b.length > 4) {
            throw new IllegalArgumentException();
        } else {
            long ret = 0;
            for (int i = 0; i < b.length; i++) {
                ret = ret | ((b[i] & 0xFF) << ((b.length - 1 - i) * 8));
            }
            if (ret > Integer.MAX_VALUE) {
                throw new IllegalArgumentException();
            } else {
                return (int) ret;
            }
        }
    }

    public static long byteArrayToLong(byte[] b) {
        if (b.length > 8) {
            throw new IllegalArgumentException();
        } else {
            long ret = 0;
            for (int i = 0; i < b.length; i++) {
                ret = ret | ((b[i] & 0xFFL) << ((b.length - 1 - i) * 8));
            }
            return ret;
        }
    }

//    public static String bytesToHex(byte[] bytes) {
//        final char[] hexArray = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
//        char[] hexChars = new char[bytes.length * 2];
//        int v;
//        for (int j = 0; j < bytes.length; j++) {
//            v = bytes[j] & 0xFF;
//
//            if (log.isLoggable(Level.FINE)) {
//                log.log(Level.FINE, "Integer Value = {0} ", new Object[]{v});
//            }
//
//            hexChars[j * 2] = hexArray[v >>> 4];
//            hexChars[j * 2 + 1] = hexArray[v & 0x0F];
//
//            if (log.isLoggable(Level.FINE)) {
//                log.log(Level.FINE, "Char Value = {0}{1} ", new Object[]{hexChars[j * 2], hexChars[j * 2 + 1]});
//            }
//        }
//        return new String(hexChars);
//    }
//
//    public static byte[] hexToBytes(String hex) {
//        if (hex.length() % 2 != 0) {
//            throw new IllegalArgumentException();
//        }
//        final byte result[] = new byte[hex.length() / 2];
//        for (int i = 0; i < hex.length(); i += 2) {
//            String curr = hex.substring(i, i + 2);
//            
//            if (log.isLoggable(Level.FINE)) {
//                log.log(Level.FINE, "String Value = {0} ", new Object[]{curr});
//            }
//            
//            result[i / 2] = (byte) Integer.parseInt(curr.toString(), 16);
//            
//            if (log.isLoggable(Level.FINE)) {
//                log.log(Level.FINE, "Integer Value = {0} ", new Object[]{(int) result[i/2] & 0xFF});
//            }
//        }
//        return result;
//    }

    public static String toHexString(byte[] array) {
        return DatatypeConverter.printHexBinary(array);
    }

    public static byte[] toByteArray(String s) {
        return DatatypeConverter.parseHexBinary(s);
    }
}
